package chatNI;

import messages.*;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

import chatControler.ChatControler;
import chatModel.*;

/**
 * Cette classe est le Thread qui gère la réception 
 * des messages en mode datagrame
 * 
 */
public class ThreadUdpEcoute extends Thread {
	
	private DatagramSocket socketUdp;
	private ChatControler chatControler;
	private boolean actif;
	
	
	/**
         * Constructeur de la classe
         * @param socketUdp Socket sur lequel on écoute les message
         * @param chatControler ChatControler pour le prévenir des messages reçus
         * @param actif Indique si le Thread est actif
         */
	public ThreadUdpEcoute(DatagramSocket socketUdp, ChatControler chatControler, boolean actif) {
		super();
		this.socketUdp = socketUdp;
		this.chatControler = chatControler;
		this.actif=actif;
	}
	
        /**
         * Permet de savoir si le Thread est en train d'écouter le réseau
         * @return True si le Thread est actif, false sinon
         */
	public boolean getActif(){
		return this.actif;
	}
	
        /**
         * Permet de changer l'état du Thread
         * @param actif True pour activer l'écoute des message, false sinon
         */
	public void setActif(boolean actif){
		this.actif=actif;
	}
        
	/**
         * Méthode qui exécute les actions nécessaires lors du démarrage du Thread
         * Si le Thread est actif, il récupère en boucle les messages sur les sockets
         */
	public void run(){
		while(actif){
			receiveMsg(socketUdp);
		}
		System.out.println("reception fermée");
	}
	
        /**
         * Méthode qui regarde les messages reçus sur le socket
         * @see chatControler.ChatControler#traiterNewMsg(messages.Message) traiterNewMsg
         * @param socketUdp Socket sur lequel il faut récupérer les messages
         */
	public void receiveMsg(DatagramSocket socketUdp){
		
		byte[] recvData;
		DatagramPacket myPacket;
		Message recvMessage;
		int size;
		
		try {
			size = socketUdp.getReceiveBufferSize();
			recvData = new byte[size];
			myPacket = new DatagramPacket(recvData, recvData.length);
			socketUdp.receive(myPacket);
			recvMessage = MessagesFactory.getMessage(myPacket.getData());
			
			// Il faut maintenant envoyer le message reçu au ChatControler pour savoir ce qu'il faut faire ensuite
			System.out.println("On a reçu un message de : " + recvMessage.getUsername());
			chatControler.traiterNewMsg(recvMessage);
			
		} catch (SocketException e) {
			System.out.println("erreur reception taille buffer");
			e.printStackTrace();
		} catch (IOException e) {
			System.out.println("Erreur reception");
			e.printStackTrace();
		} catch (MessageCreationException e) {
			e.printStackTrace();
		}
	}
	
	
	
}
